home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dutil / save / hunks.c < prev   
C/C++ Source or Header  |  1994-01-30  |  6KB  |  290 lines
  1.  
  2. /*
  3.  *  HUNKS.C
  4.  *
  5.  *  HUNKS executable
  6.  *
  7.  * (c)Copyright 1992 Obvious Implementations Corp, All Rights Reserved
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <lib/version.h>
  14.  
  15. #ifdef _DCC
  16. IDENT("hunks",".3");
  17. DCOPYRIGHT;
  18. #else
  19. #define __aligned
  20. #endif
  21.  
  22. typedef unsigned char ubyte;
  23. typedef unsigned short uword;
  24. typedef unsigned long ulong;
  25.  
  26. void DumpHunks(char *);
  27. ulong fgetl(FILE *);
  28. void fgetname(FILE *, char *, long);
  29. void zfseek(FILE *, long);
  30.  
  31. short AllOpt;
  32.  
  33. main(ac, av)
  34. int ac;
  35. char *av[];
  36. {
  37.     short i;
  38.  
  39. #ifndef unix
  40.     expand_args(ac, av, &ac, &av);
  41. #endif
  42.  
  43.     if (ac == 1) {
  44. #ifdef _DCC
  45.     printf("%s\n%s\n", Ident, DCopyright);
  46. #endif
  47.     puts("hunks [-all] executeable/object_module");
  48.     exit(0);
  49.     }
  50.     for (i = 1; i < ac; ++i) {
  51.     char *ptr = av[i];
  52.  
  53.     if (*ptr != '-') {
  54.         printf("\n** FILE %s **\n\n", ptr);
  55.         DumpHunks(ptr);
  56.         continue;
  57.     }
  58.     if (stricmp(ptr, "-all") == 0)
  59.         AllOpt = 1;
  60.     }
  61.     return(0);
  62. }
  63.  
  64. void
  65. DumpHunks(fileName)
  66. char *fileName;
  67. {
  68.     FILE *fi;
  69.     __aligned char buf[256];
  70.  
  71.     if (fi = fopen(fileName, "r")) {
  72.     ulong type;
  73.     ulong flags;
  74.     ulong skip;
  75.     ulong n;
  76.  
  77.     while (type = fgetl(fi)) {
  78.         skip = 0;
  79.  
  80.         flags = type & 0xFFFF0000;
  81.         type  = type & 0x0000FFFF;
  82.  
  83.         switch(type) {
  84.         case 0x3F3:         /*    HUNK_HEADER */
  85.         {
  86.             long hno;
  87.  
  88.             n = fgetl(fi);
  89.             fgetname(fi, buf, n);
  90.             skip = fgetl(fi);
  91.             printf("%08lx HUNK_HEADER\tname=%s\tsize=%d ", 0x3F3, buf, skip);
  92.             printf("first=%d ", hno = fgetl(fi));
  93.             printf("last=%d\n", fgetl(fi));
  94.  
  95.             while (skip) {
  96.             --skip;
  97.             n = fgetl(fi);
  98.             printf("    %08lx HUNK %d SIZE %d", n, hno, (n & 0x00FFFFFF) * 4);
  99.             switch(n & 0xC0000000) {
  100.             case 0x00000000:
  101.                 break;
  102.             case 0x40000000:
  103.                 printf(" MEMF_CHIP");
  104.                 break;
  105.             case 0x80000000:
  106.                 printf(" MEMF_FAST");
  107.                 break;
  108.             case 0xC0000000:
  109.                 printf(" MEMF_CHIP|MEMF_FAST");
  110.                 break;
  111.             }
  112.             puts("");
  113.             ++hno;
  114.             }
  115.         }
  116.         break;
  117.         case 0x3E9:         /*    HUNK_CODE   */
  118.         skip = fgetl(fi);
  119.         printf("%08lx HUNK_CODE\tsize=%d\n", type, skip * 4);
  120.         break;
  121.         case 0x3EA:         /*    HUNK_DATA    */
  122.         skip = fgetl(fi);
  123.         printf("%08lx HUNK_DATA\tsize=%d\n", type, skip * 4);
  124.         break;
  125.         break;
  126.         case 0x3EB:         /*    HUNK_BSS    */
  127.         skip = fgetl(fi);
  128.         printf("%08lx HUNK_BSS\tsize=%d\n", type, skip * 4);
  129.         skip = 0;
  130.         break;
  131.         case 0x3EC:         /*    HUNK_RELOC32    */
  132.         printf("%08lx HUNK_RELOC-ABSOLUTE32\n", type);
  133.         case 0x3ED:         /*    HUNK_RELOC16-PC */
  134.         if (type == 0x3ED)
  135.             printf("%08lx HUNK_RELOC-PCREL16\n", type);
  136.         case 0x3EE:         /*    HUNK_RELOC8    */
  137.         if (type == 0x3EE)
  138.             printf("%08lx HUNK_RELOC-PCREL8\n", type);
  139.         case 0x3F8:         /*    HUNK_RELOC16-D    (special) */
  140.         if (type == 0x3F8)
  141.             printf("%08lx HUNK_RELOC-DATAREL16\n", type);
  142.         while (skip = fgetl(fi)) {
  143.             n = fgetl(fi);
  144.             printf("    %d relocations to hunk %d\n", skip, n);
  145.             if (AllOpt) {
  146.             while (skip) {
  147.                 --skip;
  148.                 n = fgetl(fi);
  149.                 printf("\t@0x%08lx\n", n);
  150.             }
  151.             } else {
  152.             zfseek(fi, skip);
  153.             }
  154.         }
  155.         break;
  156.         case 0x3EF:         /*    HUNK_EXT    */
  157.         printf("%08lx HUNK_EXT\n", type);
  158.         case 0x3F0:         /*    HUNK_SYMBOL    */
  159.         if (type == 0x3F0)
  160.             printf("%08lx HUNK_SYMBOL\n", type);
  161.         while (skip = fgetl(fi)) {
  162.             ubyte symType = skip >> 24;
  163.  
  164.             skip &= 0x00FFFFFF;
  165.             fgetname(fi, buf, skip);
  166.             printf("    0x%02x:%-15s", symType, buf);
  167.  
  168.             switch(symType) {
  169.             case 0:        /*    SYMB    */
  170.             printf("\tSYMBOL");
  171.             case 1:        /*    DEF    */
  172.             if (symType == 1)
  173.                 printf("\tXDEF");
  174.             case 2:        /*    ABS    */
  175.             if (symType == 2)
  176.                 printf("\tABS-SYM");
  177.             case 3:        /*    RES    */
  178.             if (symType == 3)
  179.                 printf("\tRES-SYM");
  180.             n = fgetl(fi);
  181.             printf("\tval=0x%08lx", n);
  182.             break;
  183.             case 130:        /*    COMMON (def)*/
  184.             n = fgetl(fi);
  185.             printf("\tCOMMON size=0x%04lx", n);
  186.             break;
  187.             case 135:        /*    REF32-pc    */
  188.             printf("\tPCREL-32");
  189.             case 129:        /*    REF32        */
  190.             if (symType == 129)
  191.                 printf("\tABSOLUTE-32");
  192.             case 131:        /*    REF16-pc    */
  193.             if (symType == 131)
  194.                 printf("\tPCREL-16");
  195.             case 132:        /*    REF8        */
  196.             if (symType == 132)
  197.                 printf("\tPCREL-8");
  198.             case 134:        /*    REF16D        */
  199.             if (symType == 134)
  200.                 printf("\tDATAREL-16");
  201.             n = fgetl(fi);
  202.             printf("\t%d relocs", n);
  203.             zfseek(fi, n);
  204.             break;
  205.             default:
  206.             printf("\tUNKNOWN TYPE FIELD");
  207.             }
  208.             puts("");
  209.         }
  210.         break;
  211.         case 0x3F1:         /*    HUNK_DEBUG        */
  212.         skip = fgetl(fi);
  213.         printf("%08lx HUNK_DEBUG\t%d bytes\n", type, skip * 4);
  214.         break;
  215.         case 0x3E8:
  216.         n = fgetl(fi);
  217.         fgetname(fi, buf, n);
  218.         printf("%08lx HUNK_NAME\tname=%s\n", type, buf);
  219.         break;
  220.         case 0x3E7:
  221.         n = fgetl(fi);
  222.         fgetname(fi, buf, n);
  223.         printf("%08lx HUNK_UNIT\tname=%s\n", type, buf);
  224.         break;
  225.         case 0x3F2:
  226.         printf("%08lx HUNK_END\n\n", type);
  227.         break;
  228.         default:
  229.         printf("%08lx UNKNOWN HUNK TYPE\n", type);
  230.         break;
  231.         }
  232.         if (skip)
  233.         zfseek(fi, skip);
  234.     }
  235.     }
  236. }
  237.  
  238. ulong
  239. fgetl(fi)
  240. FILE *fi;
  241. {
  242.     ulong n;
  243.     short c;
  244.  
  245.     if ((c = getc(fi)) != EOF) {
  246.     n = c << 24;
  247.     if ((c = getc(fi)) != EOF) {
  248.         n |= c << 16;
  249.         if ((c = getc(fi)) != EOF) {
  250.         n |= c << 8;
  251.         if ((c = getc(fi)) != EOF) {
  252.             n |= c;
  253.             return(n);
  254.         }
  255.         }
  256.     }
  257.     }
  258.     return(0);
  259. }
  260.  
  261. void
  262. fgetname(fi, buf, len)
  263. FILE *fi;
  264. char *buf;
  265. long len;
  266. {
  267.     long n;
  268.  
  269.     for (n = 0; n < len && n < 255/4; ++n) {
  270.     *((long *)buf + n) = fgetl(fi);
  271.     }
  272.     *((long *)buf + n) = 0;
  273. }
  274.  
  275. void
  276. zfseek(fi, numLongs)
  277. FILE *fi;
  278. long numLongs;
  279. {
  280.     if (numLongs < 32) {
  281.     while (numLongs) {
  282.         --numLongs;
  283.         fgetl(fi);
  284.     }
  285.     } else {
  286.     fseek(fi, numLongs * 4, 1);
  287.     }
  288. }
  289.  
  290.